home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ConfigParser.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  15KB  |  526 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import re
  5. __all__ = [
  6.     'NoSectionError',
  7.     'DuplicateSectionError',
  8.     'NoOptionError',
  9.     'InterpolationError',
  10.     'InterpolationDepthError',
  11.     'InterpolationSyntaxError',
  12.     'ParsingError',
  13.     'MissingSectionHeaderError',
  14.     'ConfigParser',
  15.     'SafeConfigParser',
  16.     'RawConfigParser',
  17.     'DEFAULTSECT',
  18.     'MAX_INTERPOLATION_DEPTH']
  19. DEFAULTSECT = 'DEFAULT'
  20. MAX_INTERPOLATION_DEPTH = 10
  21.  
  22. class Error(Exception):
  23.     
  24.     def __init__(self, msg = ''):
  25.         self.message = msg
  26.         Exception.__init__(self, msg)
  27.  
  28.     
  29.     def __repr__(self):
  30.         return self.message
  31.  
  32.     __str__ = __repr__
  33.  
  34.  
  35. class NoSectionError(Error):
  36.     
  37.     def __init__(self, section):
  38.         Error.__init__(self, 'No section: %r' % (section,))
  39.         self.section = section
  40.  
  41.  
  42.  
  43. class DuplicateSectionError(Error):
  44.     
  45.     def __init__(self, section):
  46.         Error.__init__(self, 'Section %r already exists' % section)
  47.         self.section = section
  48.  
  49.  
  50.  
  51. class NoOptionError(Error):
  52.     
  53.     def __init__(self, option, section):
  54.         Error.__init__(self, 'No option %r in section: %r' % (option, section))
  55.         self.option = option
  56.         self.section = section
  57.  
  58.  
  59.  
  60. class InterpolationError(Error):
  61.     
  62.     def __init__(self, option, section, msg):
  63.         Error.__init__(self, msg)
  64.         self.option = option
  65.         self.section = section
  66.  
  67.  
  68.  
  69. class InterpolationMissingOptionError(InterpolationError):
  70.     
  71.     def __init__(self, option, section, rawval, reference):
  72.         msg = 'Bad value substitution:\n\tsection: [%s]\n\toption : %s\n\tkey    : %s\n\trawval : %s\n' % (section, option, reference, rawval)
  73.         InterpolationError.__init__(self, option, section, msg)
  74.         self.reference = reference
  75.  
  76.  
  77.  
  78. class InterpolationSyntaxError(InterpolationError):
  79.     pass
  80.  
  81.  
  82. class InterpolationDepthError(InterpolationError):
  83.     
  84.     def __init__(self, option, section, rawval):
  85.         msg = 'Value interpolation too deeply recursive:\n\tsection: [%s]\n\toption : %s\n\trawval : %s\n' % (section, option, rawval)
  86.         InterpolationError.__init__(self, option, section, msg)
  87.  
  88.  
  89.  
  90. class ParsingError(Error):
  91.     
  92.     def __init__(self, filename):
  93.         Error.__init__(self, 'File contains parsing errors: %s' % filename)
  94.         self.filename = filename
  95.         self.errors = []
  96.  
  97.     
  98.     def append(self, lineno, line):
  99.         self.errors.append((lineno, line))
  100.         self.message += '\n\t[line %2d]: %s' % (lineno, line)
  101.  
  102.  
  103.  
  104. class MissingSectionHeaderError(ParsingError):
  105.     
  106.     def __init__(self, filename, lineno, line):
  107.         Error.__init__(self, 'File contains no section headers.\nfile: %s, line: %d\n%r' % (filename, lineno, line))
  108.         self.filename = filename
  109.         self.lineno = lineno
  110.         self.line = line
  111.  
  112.  
  113.  
  114. class RawConfigParser:
  115.     
  116.     def __init__(self, defaults = None):
  117.         self._sections = { }
  118.         self._defaults = { }
  119.         if defaults:
  120.             for key, value in defaults.items():
  121.                 self._defaults[self.optionxform(key)] = value
  122.             
  123.         
  124.  
  125.     
  126.     def defaults(self):
  127.         return self._defaults
  128.  
  129.     
  130.     def sections(self):
  131.         return self._sections.keys()
  132.  
  133.     
  134.     def add_section(self, section):
  135.         if section in self._sections:
  136.             raise DuplicateSectionError(section)
  137.         
  138.         self._sections[section] = { }
  139.  
  140.     
  141.     def has_section(self, section):
  142.         return section in self._sections
  143.  
  144.     
  145.     def options(self, section):
  146.         
  147.         try:
  148.             opts = self._sections[section].copy()
  149.         except KeyError:
  150.             raise NoSectionError(section)
  151.  
  152.         opts.update(self._defaults)
  153.         if '__name__' in opts:
  154.             del opts['__name__']
  155.         
  156.         return opts.keys()
  157.  
  158.     
  159.     def read(self, filenames):
  160.         if isinstance(filenames, basestring):
  161.             filenames = [
  162.                 filenames]
  163.         
  164.         read_ok = []
  165.         for filename in filenames:
  166.             
  167.             try:
  168.                 fp = open(filename)
  169.             except IOError:
  170.                 continue
  171.  
  172.             self._read(fp, filename)
  173.             fp.close()
  174.             read_ok.append(filename)
  175.         
  176.         return read_ok
  177.  
  178.     
  179.     def readfp(self, fp, filename = None):
  180.         if filename is None:
  181.             
  182.             try:
  183.                 filename = fp.name
  184.             except AttributeError:
  185.                 filename = '<???>'
  186.             except:
  187.                 None<EXCEPTION MATCH>AttributeError
  188.             
  189.  
  190.         None<EXCEPTION MATCH>AttributeError
  191.         self._read(fp, filename)
  192.  
  193.     
  194.     def get(self, section, option):
  195.         opt = self.optionxform(option)
  196.         if section not in self._sections:
  197.             if section != DEFAULTSECT:
  198.                 raise NoSectionError(section)
  199.             
  200.             if opt in self._defaults:
  201.                 return self._defaults[opt]
  202.             else:
  203.                 raise NoOptionError(option, section)
  204.         elif opt in self._sections[section]:
  205.             return self._sections[section][opt]
  206.         elif opt in self._defaults:
  207.             return self._defaults[opt]
  208.         else:
  209.             raise NoOptionError(option, section)
  210.  
  211.     
  212.     def items(self, section):
  213.         
  214.         try:
  215.             d2 = self._sections[section]
  216.         except KeyError:
  217.             if section != DEFAULTSECT:
  218.                 raise NoSectionError(section)
  219.             
  220.             d2 = { }
  221.  
  222.         d = self._defaults.copy()
  223.         d.update(d2)
  224.         if '__name__' in d:
  225.             del d['__name__']
  226.         
  227.         return d.items()
  228.  
  229.     
  230.     def _get(self, section, conv, option):
  231.         return conv(self.get(section, option))
  232.  
  233.     
  234.     def getint(self, section, option):
  235.         return self._get(section, int, option)
  236.  
  237.     
  238.     def getfloat(self, section, option):
  239.         return self._get(section, float, option)
  240.  
  241.     _boolean_states = {
  242.         '1': True,
  243.         'yes': True,
  244.         'true': True,
  245.         'on': True,
  246.         '0': False,
  247.         'no': False,
  248.         'false': False,
  249.         'off': False }
  250.     
  251.     def getboolean(self, section, option):
  252.         v = self.get(section, option)
  253.         if v.lower() not in self._boolean_states:
  254.             raise ValueError, 'Not a boolean: %s' % v
  255.         
  256.         return self._boolean_states[v.lower()]
  257.  
  258.     
  259.     def optionxform(self, optionstr):
  260.         return optionstr.lower()
  261.  
  262.     
  263.     def has_option(self, section, option):
  264.         if not section or section == DEFAULTSECT:
  265.             option = self.optionxform(option)
  266.             return option in self._defaults
  267.         elif section not in self._sections:
  268.             return False
  269.         else:
  270.             option = self.optionxform(option)
  271.             if not option in self._sections[section]:
  272.                 pass
  273.             return option in self._defaults
  274.  
  275.     
  276.     def set(self, section, option, value):
  277.         if not section or section == DEFAULTSECT:
  278.             sectdict = self._defaults
  279.         else:
  280.             
  281.             try:
  282.                 sectdict = self._sections[section]
  283.             except KeyError:
  284.                 raise NoSectionError(section)
  285.  
  286.         sectdict[self.optionxform(option)] = value
  287.  
  288.     
  289.     def write(self, fp):
  290.         if self._defaults:
  291.             fp.write('[%s]\n' % DEFAULTSECT)
  292.             for key, value in self._defaults.items():
  293.                 fp.write('%s = %s\n' % (key, str(value).replace('\n', '\n\t')))
  294.             
  295.             fp.write('\n')
  296.         
  297.         for section in self._sections:
  298.             fp.write('[%s]\n' % section)
  299.             for key, value in self._sections[section].items():
  300.                 if key != '__name__':
  301.                     fp.write('%s = %s\n' % (key, str(value).replace('\n', '\n\t')))
  302.                     continue
  303.             
  304.             fp.write('\n')
  305.         
  306.  
  307.     
  308.     def remove_option(self, section, option):
  309.         if not section or section == DEFAULTSECT:
  310.             sectdict = self._defaults
  311.         else:
  312.             
  313.             try:
  314.                 sectdict = self._sections[section]
  315.             except KeyError:
  316.                 raise NoSectionError(section)
  317.  
  318.         option = self.optionxform(option)
  319.         existed = option in sectdict
  320.         if existed:
  321.             del sectdict[option]
  322.         
  323.         return existed
  324.  
  325.     
  326.     def remove_section(self, section):
  327.         existed = section in self._sections
  328.         if existed:
  329.             del self._sections[section]
  330.         
  331.         return existed
  332.  
  333.     SECTCRE = re.compile('\\[(?P<header>[^]]+)\\]')
  334.     OPTCRE = re.compile('(?P<option>[^:=\\s][^:=]*)\\s*(?P<vi>[:=])\\s*(?P<value>.*)$')
  335.     
  336.     def _read(self, fp, fpname):
  337.         cursect = None
  338.         optname = None
  339.         lineno = 0
  340.         e = None
  341.         while True:
  342.             line = fp.readline()
  343.             if not line:
  344.                 break
  345.             
  346.             lineno = lineno + 1
  347.             if line.strip() == '' or line[0] in '#;':
  348.                 continue
  349.             
  350.             if line.split(None, 1)[0].lower() == 'rem' and line[0] in 'rR':
  351.                 continue
  352.             
  353.             if line[0].isspace() and cursect is not None and optname:
  354.                 value = line.strip()
  355.                 if value:
  356.                     cursect[optname] = '%s\n%s' % (cursect[optname], value)
  357.                 
  358.             value
  359.             mo = self.SECTCRE.match(line)
  360.             if mo:
  361.                 sectname = mo.group('header')
  362.                 if sectname in self._sections:
  363.                     cursect = self._sections[sectname]
  364.                 elif sectname == DEFAULTSECT:
  365.                     cursect = self._defaults
  366.                 else:
  367.                     cursect = {
  368.                         '__name__': sectname }
  369.                     self._sections[sectname] = cursect
  370.                 optname = None
  371.                 continue
  372.             if cursect is None:
  373.                 raise MissingSectionHeaderError(fpname, lineno, line)
  374.                 continue
  375.             mo = self.OPTCRE.match(line)
  376.             if mo:
  377.                 (optname, vi, optval) = mo.group('option', 'vi', 'value')
  378.                 if vi in ('=', ':') and ';' in optval:
  379.                     pos = optval.find(';')
  380.                     if pos != -1 and optval[pos - 1].isspace():
  381.                         optval = optval[:pos]
  382.                     
  383.                 
  384.                 optval = optval.strip()
  385.                 if optval == '""':
  386.                     optval = ''
  387.                 
  388.                 optname = self.optionxform(optname.rstrip())
  389.                 cursect[optname] = optval
  390.                 continue
  391.             if not e:
  392.                 e = ParsingError(fpname)
  393.             
  394.             e.append(lineno, repr(line))
  395.         if e:
  396.             raise e
  397.         
  398.  
  399.  
  400.  
  401. class ConfigParser(RawConfigParser):
  402.     
  403.     def get(self, section, option, raw = False, vars = None):
  404.         d = self._defaults.copy()
  405.         
  406.         try:
  407.             d.update(self._sections[section])
  408.         except KeyError:
  409.             if section != DEFAULTSECT:
  410.                 raise NoSectionError(section)
  411.             
  412.         except:
  413.             section != DEFAULTSECT
  414.  
  415.         if vars:
  416.             for key, value in vars.items():
  417.                 d[self.optionxform(key)] = value
  418.             
  419.         
  420.         option = self.optionxform(option)
  421.         
  422.         try:
  423.             value = d[option]
  424.         except KeyError:
  425.             raise NoOptionError(option, section)
  426.  
  427.         if raw:
  428.             return value
  429.         else:
  430.             return self._interpolate(section, option, value, d)
  431.  
  432.     
  433.     def items(self, section, raw = False, vars = None):
  434.         d = self._defaults.copy()
  435.         
  436.         try:
  437.             d.update(self._sections[section])
  438.         except KeyError:
  439.             if section != DEFAULTSECT:
  440.                 raise NoSectionError(section)
  441.             
  442.         except:
  443.             section != DEFAULTSECT
  444.  
  445.         if vars:
  446.             for key, value in vars.items():
  447.                 d[self.optionxform(key)] = value
  448.             
  449.         
  450.         options = d.keys()
  451.         if '__name__' in options:
  452.             options.remove('__name__')
  453.         
  454.  
  455.     
  456.     def _interpolate(self, section, option, rawval, vars):
  457.         value = rawval
  458.         depth = MAX_INTERPOLATION_DEPTH
  459.         while depth:
  460.             depth -= 1
  461.             if '%(' in value:
  462.                 value = self._KEYCRE.sub(self._interpolation_replace, value)
  463.                 
  464.                 try:
  465.                     value = value % vars
  466.                 except KeyError:
  467.                     e = None
  468.                     raise InterpolationMissingOptionError(option, section, rawval, e[0])
  469.                 except:
  470.                     None<EXCEPTION MATCH>KeyError
  471.                 
  472.  
  473.             None<EXCEPTION MATCH>KeyError
  474.             break
  475.         if '%(' in value:
  476.             raise InterpolationDepthError(option, section, rawval)
  477.         
  478.         return value
  479.  
  480.     _KEYCRE = re.compile('%\\(([^)]*)\\)s|.')
  481.     
  482.     def _interpolation_replace(self, match):
  483.         s = match.group(1)
  484.         if s is None:
  485.             return match.group()
  486.         else:
  487.             return '%%(%s)s' % self.optionxform(s)
  488.  
  489.  
  490.  
  491. class SafeConfigParser(ConfigParser):
  492.     
  493.     def _interpolate(self, section, option, rawval, vars):
  494.         L = []
  495.         self._interpolate_some(option, L, rawval, section, vars, 1)
  496.         return ''.join(L)
  497.  
  498.     _interpvar_match = re.compile('%\\(([^)]+)\\)s').match
  499.     
  500.     def _interpolate_some(self, option, accum, rest, section, map, depth):
  501.         if depth > MAX_INTERPOLATION_DEPTH:
  502.             raise InterpolationDepthError(option, section, rest)
  503.         
  504.         while rest:
  505.             p = rest.find('%')
  506.             if p < 0:
  507.                 accum.append(rest)
  508.                 return None
  509.             
  510.             if p > 0:
  511.                 accum.append(rest[:p])
  512.                 rest = rest[p:]
  513.             
  514.             c = rest[1:2]
  515.             None if c == '%' else '%' in v
  516.             raise InterpolationSyntaxError(option, section, "'%%' must be followed by '%%' or '(', found: %r" % (rest,))
  517.  
  518.     
  519.     def set(self, section, option, value):
  520.         if not isinstance(value, basestring):
  521.             raise TypeError('option values must be strings')
  522.         
  523.         ConfigParser.set(self, section, option, value)
  524.  
  525.  
  526.